home *** CD-ROM | disk | FTP | other *** search
/ Gigarom 4 / Mac Giga-ROM 4.0 - 1993.toast / FILES / EXT / P-T / PowerLock II.cpt / PowerLock ƒ / AddOnsƒ / AccessTimes.p < prev    next >
Text File  |  1991-12-02  |  6KB  |  194 lines
  1. {AccessTimes adOn resource}
  2. {v1.0    November 1991}
  3.  
  4. {Use AccessTimes to restrict the times that people can access your Macintosh}
  5. {Simply enter a time string against each user name & PowerLock will do the rest}
  6. {eg        0-24 gives 24 hour access,  16-20 gives access between 4:00pm and 8:59pm}
  7.  
  8. {data is stored inside the PowerLock Prefs file active at the time the AddOn is used (in STR#200)}
  9.  
  10. {Compile as a code resource, name=whatever, type ='adOn', ID=0, Attributes=00}
  11. {Save in file 'PowerLock Add-Ons' - file type 'adOn', creator 'PwrL'}
  12. {Store file inside the same folder as 'PowerLock Prefs'}
  13.  
  14. {THINK Pascal requires the following build order:}
  15. {DRVRRuntime.lib        (RSRCRuntime.lib for Think Pascal V4)}
  16. {Interface.lib}
  17. {AddOnIntf.p}
  18. {AccessTimer.p        -this file}
  19.  
  20. {You must also set the resource file to 'AccessTimer.rsrc' in Run Options...}
  21.  
  22.  
  23. unit AccessTimes;
  24. interface
  25.  
  26.     uses
  27.         adOnIntf;        {include any other units you want to use here}
  28.  
  29.     procedure main (req: integer; addOn: adOnPtr);        {must be called 'main' & have these parameters}
  30.  
  31. implementation
  32.  
  33.     const
  34.         VERSION = 'AccessTimer, © Rohan Cook, v1.00, 2 Dec 91';        {change this to whatever you want the aReqVersion request to return}
  35.  
  36.  
  37. {Utility Procedures & Functions used by this Add-On}
  38.     function Num2Str (num: longint): string;
  39. {converts numeric to string - uses Toolbox Procedure}
  40.         var
  41.             str: str255;
  42.     begin
  43.         NumToString(num, str);
  44.         Num2Str := str
  45.     end;
  46.  
  47.     function str2Num (str: str255): longint;
  48. {converts string to numeric - uses Toolbox Procedure}
  49.         var
  50.             num: longint;
  51.     begin
  52.         stringToNum(str, num);
  53.         str2Num := num;
  54.     end;
  55.  
  56.     function getDText (dlg: dialogPtr; item: integer): string;
  57. {given a dialog ptr and an item number return its text - only 255 chars are returned}
  58.         var
  59.             iType: integer;
  60.             iHandle: handle;
  61.             ibox: rect;
  62.             tempStr: str255;
  63.     begin
  64.         getDItem(dlg, item, iType, iHandle, Ibox);
  65.         getIText(iHandle, tempStr);
  66.         getDText := tempStr;
  67.     end;
  68.  
  69.     procedure setDText (dlg: dialogPtr; item: integer; str: string);
  70. {given dialog ptr, item number and a string - set the specified dialog item's text}
  71. {to that contained in STR}
  72.         var
  73.             iType: integer;
  74.             iHandle: handle;
  75.             ibox: rect;
  76.     begin
  77.         getDItem(dlg, item, iType, iHandle, Ibox);
  78.         setIText(iHandle, str);
  79.     end;
  80.  
  81.     procedure main (req: integer; addOn: adOnPtr);
  82.         const
  83.             FIRSTUSERNAME = 3;
  84.             ACCESSDLOG = 200;
  85.             TIMESTR = 200;
  86.         var
  87.             dlg: dialogPtr;
  88.             item, i, users, user, prevResFile: integer;
  89.             dash, fromHour, toHour: integer;
  90.             d: dateTimeRec;
  91.             s: str255;
  92.             timesH, resH: handle;
  93.             err: OSErr;
  94.  
  95.  
  96.         procedure UsePrefs;        {send callbacks to use the Prefs file, rather than the add0n file for resources}
  97.         begin
  98.             DoCBReq(cbReqPrefsResFile, addOn);
  99.             UseResFile(addOn^.fileRef);
  100.         end;
  101.  
  102.         procedure UseAddOn;        {send callbacks to use the AddOn file for resources}
  103.         begin
  104.             DoCBReq(cbReqAddOnResFile, addOn);
  105.             UseResFile(addOn^.fileRef);
  106.         end;
  107.  
  108.     begin
  109.  
  110.         case req of        {can receive any type of request as defined in the adOnIntf file - remember the OTHERWISE!}
  111.  
  112.             aReqPWOk:         {password was OK, now let's check if it's within authorised times}
  113.                 begin
  114.                     prevResFile := CurResFile;        {remember what Resource File was in use when we started}
  115.                     UsePrefs;
  116.                     DoCBReq(cbReqUsers, addOn);    {see if we're multiple users - if not, ignore this addon}
  117.                     if str2num(addOn^.result) > 1 then
  118.                         begin
  119.                             DoCBReq(cbReqUserID, addOn);    {Get userID of current User}
  120.                             user := str2num(addOn^.result);
  121.                             GetIndString(s, TIMESTR, user);    {Get access times for this user from STR# resource}
  122.                             dash := pos('-', s);                    {strip start hour and end hour}
  123.                             fromHour := str2num(copy(s, 1, dash - 1));
  124.                             toHour := str2num(copy(s, dash + 1, length(s)));
  125.                             GetTime(d);
  126.                             if (dash <> 0) & ((d.hour < fromHour) or (d.hour > toHour)) then        {if no dash in time setting, then ignore it}
  127.                                 begin
  128.                                     addOn^.request := 'You are not authorised to use this Macintosh at this time';
  129.                                     DoCBReq(cbReqMsg, addOn);
  130.                                     addOn^.continue := false;
  131.                                 end;
  132.                             UseResFile(prevResFile);        {important:  restore the current resource file to how you found it!}
  133.                         end;
  134.                 end;
  135.             aReqUserListBtn:     {popup times dialog whenever the UserList button is pressed in the Prefs dialog}
  136.                 begin
  137.                     prevResFile := CurResFile;
  138.                     UseAddOn;
  139.                     dlg := GetNewDialog(accessDLOG, nil, pointer(-1));    {Get the AccessTimes dialog from the add-on resource fork}
  140.                     DoCBReq(cbReqUsers, addOn);
  141.                     users := str2num(addOn^.result);
  142.                     for i := 1 to users do
  143.                         begin
  144.                             addOn^.request := num2str(i);
  145.                             DoCBReq(cbReqUser, addOn);
  146.                             SetDText(dlg, FIRSTUSERNAME + i - 1, addOn^.result);        {fill in all known usernames in the dialog}
  147.                         end;
  148.                     UsePrefs;
  149.                     for i := 1 to 5 do
  150.                         begin
  151.                             GetIndString(s, TIMESTR, i);
  152.                             SetDText(dlg, FIRSTUSERNAME + 5 + i - 1, s);                    {fill in current access time settings}
  153.                         end;
  154.                     ShowWindow(dlg);
  155.                     repeat
  156.                         modalDialog(nil, item);
  157.                     until (item = 1) or (item = 2);
  158.                     if item = 1 then        {OK, so save new info}
  159.                         begin
  160.                             timesH := NewHandle(0);
  161.                             i := 5;
  162.                             err := ptrAndHand(@i, timesH, 2);
  163. {now build up a handle to a STR# in memory}
  164.                             for i := 1 to 5 do
  165.                                 begin
  166.                                     s := GetDText(dlg, FIRSTUSERNAME + 5 + i - 1);        {get the access times from the dialog}
  167.                                     err := ptrAndHand(@s, timesH, length(s) + 1);
  168.                                 end;
  169.                             resH := GetResource('STR#', TIMESTR);        {remove previous user lists}
  170.                             if resH <> nil then
  171.                                 RmveResource(resH);
  172.                             AddResource(handle(timesH), 'STR#', TIMESTR, 'AccessTimes');
  173.                             WriteResource(handle(timesH));
  174.                             disposHandle(timesH);
  175.                             UpdateResFile(CurResFile);
  176.                         end;
  177.                     DisposDialog(dlg);
  178.                     UseResFile(prevResFile);
  179.                 end;
  180.  
  181.  
  182.             aReqVersion:         {returns your version information}
  183.                 begin
  184.                     addOn^.aoAOIFVers := aoIntfVersion;        {*** ALWAYS INCLUDE THIS LINE ***}
  185.  
  186.                     addOn^.result := VERSION;
  187.                 end;
  188.  
  189.             otherwise
  190.         end;
  191.     end;
  192.  
  193.  
  194. end.